/**
 * @file rtcroom.js 多人音视频房间管理sdk
 * @author binniexu
 */

let webim = require('webim_wx.min.js');
let webimhandler = require('webim_handler.js');
// 修改调整读取位置 支持授权发布模式 modify by cw 20181121
// let config = (JSON.stringify(wx.getExtConfigSync()) !== '{}' ? wx.getExtConfigSync() : require('../../../config.js')).config_trtc;
const { config: { config_trtc: config }} = require('../../../common/utils/ws/ws-config.js');
// 修改调整读取位置 支持授权发布模式 modify by cw 20181121

let serverDomain = '';
// 后台域名

let heart = '';
// 判断心跳变量

let requestSeq = 0;
// 请求id

let requestTask = [];
// 请求task
	// 用户信息

let accountInfo = {
		userID: '', // 用户ID
		userName: '', // 用户昵称
		userAvatar: '', // 用户头像URL
		userSig: '', // IM登录凭证
		sdkAppID: '', // IM应用ID
		accountType: '', // 账号集成类型
		accountMode: 0, //帐号模式，0-表示独立模式，1-表示托管模式
  token: '', // 登录RoomService后使用的票据
};

	// 房间信息

let roomInfo = {
		roomID: '', // 视频位房间ID
		roomCreator: '', //房间创建者
		roomInfo: '', // 房间自定义信息（如作为房间名称）
		mixedPlayURL: '', // 混流地址
		pushers: [], // 当前用户信息
  isDestory: false, // 是否已解散
};

	// 事件

let event = {
		onGetPusherList: function () {}, // 初始化成员列表
		onPusherJoin: function () {}, // 进房通知
		onPusherQuit: function () {}, // 退房通知
		onRoomClose: function () {}, // 群解散通知
  onRecvRoomTextMsg: function() {}, // 消息通知
	};

// 请求数
let requestNum = 0;

/**
 * [request 封装request请求]
 * @param {options}
 *   url: 请求接口url
 *   data: 请求参数
 *   success: 成功回调
 *   fail: 失败回调
 *   complete: 完成回调
 */
function request(options) {
	if (!serverDomain) {
		console.log('请求服务器域名为空，请将wxlite/config里面的url配置成你的服务器域名');
    options.fail &&
      options.fail({
			errCode: -9,
        errMsg: '请求服务器域名为空，请将wxlite/config里面的url配置成你的服务器域名',
		});
		return;
	}
	requestNum++;
  console.log('requestNum: ', requestNum);
	requestTask[requestSeq++] = wx.request({
    url:
      serverDomain +
      options.url +
      (options.params ? '?' + formatParams(options.params) + '&' : '?') +
      'userID=' +
      accountInfo.userID +
      (accountInfo.token ? '&token=' + accountInfo.token : '') +
      '&rtc_port=' +
      config.port,
		data: options.data || {},
		method: 'POST',
		header: {
      'content-type': 'application/json', // 默认值
		},
		// dataType: 'json'
		success: function (ret) {
			options.success && options.success(ret);
		},
		fail: function (ret) {
			options.fail && options.fail(ret);
		},
    complete:
      options.complete ||
      function() {
			requestNum--;
			// console.log('complete requestNum: ',requestNum);
      },
	});
}

//url encode编码
function formatParams(data) {
  let arr = [];
  for (let name in data) {
    if (data.hasOwnProperty(name)) {
      arr.push(encodeURIComponent(name) + '=' + encodeURIComponent(data[name]));
	}
  }
  return arr.join('&');
}

/**
 * [login 初始化登录信息]
 * @param {options}
 *   data: {
 *    userID: 用户ID
 *    userSig: 用户sig
 *    sdkAppID: IM应用ID
 *    userName: 用户昵称
 *    userAvatar: 用户头像地址
 *   }
 *   success: 成功回调
 *   fail: 失败回调
 *
 * @return success
 *   userName: 用户昵称
 */
function login(options) {
	if (!options || !options.data.serverDomain) {
		console.log('init参数错误', options);
    options.fail &&
      options.fail({
			errCode: -9,
        errMsg: 'init参数错误',
		});
		return;
	}
	serverDomain = options.data.serverDomain;
	accountInfo.userID = options.data.userID;
	accountInfo.userSig = options.data.userSig;
	accountInfo.sdkAppID = options.data.sdkAppID;
	accountInfo.accountType = options.data.accType;
  accountInfo.userName = options.data.userName;
	accountInfo.userAvatar = options.data.userAvatar || '123';

	request({
		url: 'login',
		params: {
			accountType: accountInfo.accountType,
			sdkAppID: accountInfo.sdkAppID,
      userSig: accountInfo.userSig,
		},
		data: {},
		success: function (ret) {
			if (ret.data.code) {
        console.error('登录到RoomService后台失败:', JSON.stringify(ret));
        options.fail &&
          options.fail({
					errCode: ret.data.code,
            errMsg: ret.data.message,
				});
				return;
			}

			accountInfo.token = ret.data.token;
			accountInfo.userID = ret.data.userID;
			// 登录IM
			loginIM({
				success: function (ret) {
          options.success &&
            options.success({
						userID: accountInfo.userID,
              userName: accountInfo.userName,
					});
				},
				fail: function (ret) {
          console.error('IM登录失败:', JSON.stringify(ret));
          options.fail &&
            options.fail({
						errCode: -999,
              errMsg: 'IM登录失败',
					});
        },
			});
		},
		fail: function (ret) {
      console.error('登录到RoomService后台失败:', JSON.stringify(ret));
			options.fail && options.fail(ret);
    },
	});
}

/**
 * [logout 结束初始化信息]
 */
function logout() {
	request({
    url: 'logout',
		success: function (ret) {},
    fail: function(ret) {},
	});
	serverDomain = '';
	accountInfo.userID = '';
	accountInfo.userSig = '';
	accountInfo.sdkAppID = '';
	accountInfo.accountType = '';
	accountInfo.userName = '';
	accountInfo.userAvatar = '';
	accountInfo.token = '';
	// 退出IM登录
	webimhandler.logout();
}

/**
 * [loginIM 登录IM]
 * @param {options}
 *   data: {
 *   	roomID: 房间ID
 *   }
 *   success: 成功回调
 *   fail: 失败回调
 */
function loginIM(options) {
	// 初始化设置参数
	webimhandler.init({
		accountMode: accountInfo.accountMode,
		accountType: accountInfo.accountType,
		sdkAppID: accountInfo.sdkAppID,
		avChatRoomId: options.roomID || 0,
		selType: webim.SESSION_TYPE.GROUP,
		selToID: options.roomID || 0,
    selSess: null, // 当前聊天会话
	});
	//当前用户身份
  let loginInfo = {
    sdkAppID: accountInfo.sdkAppID, // 用户所属应用id,必填
    appIDAt3rd: accountInfo.sdkAppID, // 用户所属应用id，必填
    accountType: accountInfo.accountType, // 用户所属应用帐号类型，必填
    identifier: accountInfo.userID, // 当前用户ID,必须是否字符串类型，选填
    identifierNick: accountInfo.userName, // 当前用户昵称，选填
    userSig: accountInfo.userSig, // 当前用户身份凭证，必须是字符串类型，选填
	};
	//监听（多终端同步）群系统消息方法，方法都定义在demo_group_notice.js文件中
  let onGroupSystemNotifys = {
		// 群被解散(全员接收)
    5: function(notify) {
			roomInfo.isDestory = true;
			event.onRoomClose({});
		},
    11: webimhandler.onRevokeGroupNotify, // 群已被回收(全员接收)
		// 用户自定义通知(默认全员接收)
    255: function(notify) {
			console.error('收到系统通知：', notify.UserDefinedField);
      let content = JSON.parse(notify.UserDefinedField);
			if (!roomInfo.isDestory && content && content.cmd == 'notifyPusherChange') {
				mergePushers();
			}
    },
	};

	//监听连接状态回调变化事件
  let onConnNotify = function(resp) {
		switch (resp.ErrorCode) {
			case webim.CONNECTION_STATUS.ON:
				//webim.Log.warn('连接状态正常...');
				break;
			case webim.CONNECTION_STATUS.OFF:
				webim.Log.warn('连接已断开，无法收到新消息，请检查下你的网络是否正常');
				break;
			default:
				webim.Log.error('未知连接状态,status=' + resp.ErrorCode);
				break;
		}
	};

	//监听事件
  let listeners = {
    onConnNotify: webimhandler.onConnNotify, // 选填
    onBigGroupMsgNotify: function(msg) {
			webimhandler.onBigGroupMsgNotify(msg, function (msgs) {
				receiveMsg(msgs);
      });
		}, //监听新消息(大群)事件，必填
    onMsgNotify: webimhandler.onMsgNotify, // 监听新消息(私聊(包括普通消息和全员推送消息)，普通群(非直播聊天室)消息)事件，必填
    onGroupSystemNotifys: onGroupSystemNotifys, // 监听（多终端同步）群系统消息事件，必填
    onGroupInfoChangeNotify: webimhandler.onGroupInfoChangeNotify,
		// 'onKickedEventCall': self.onKickedEventCall // 踢人操作
	};

	//其他对象，选填
  let others = {
    isAccessFormalEnv: true, // 是否访问正式环境，默认访问正式，选填
    isLogOn: false, // 是否开启控制台打印日志,默认开启，选填
	};

  if (accountInfo.accountMode == 1) {
    // 托管模式
		webimhandler.sdkLogin(loginInfo, listeners, others, 0, afterLoginIM, options);
  } else {
    // 独立模式
		//sdk登录
		webimhandler.sdkLogin(loginInfo, listeners, others, 0, afterLoginIM, options);
	}
}

function afterLoginIM(options) {
	if (options.errCode) {
		// webim登录失败
		console.log('IM登录失败:', options);
    options.callback.fail &&
      options.callback.fail({
			errCode: -2,
        errMsg: 'IM登录失败，如果你是在配置线上环境，请将IM域名[https://webim.tim.qq.com]配置到小程序request合法域名',
		});
		return;
	}
	// webim登录成功
	console.log('IM登录成功');
  options.callback.success &&
    options.callback.success({
      userName: accountInfo.userName,
	});
}

function afterJoinBigGroup(options) {
	if (options.errCode) {
		console.log('IM进群失败: ', options);
    options.callback.fail &&
      options.callback.fail({
			errCode: -2,
        errMsg: 'IM进群失败',
		});
		return;
	}
	console.log('进入IM房间成功: ', roomInfo.roomID);
	options.callback.success && options.callback.success({});
}

/**
 * [receiveMsg 接收消息处理]
 * @param {options}
 *
 * @return event.onRecvRoomTextMsg
 *   roomID: 房间ID
 *   userID: 用户ID
 *   nickName: 用户昵称
 *   headPic: 用户头像
 *   textMsg: 文本消息
 *   time: 消息时间
 */
function receiveMsg(msg) {
	if (!msg.content) {
		return;
	}
	console.log('IM消息: ', msg);
	if (msg.fromAccountNick == '@TIM#SYSTEM') {
		msg.fromAccountNick = '';
		msg.content = msg.content.split(';');
		msg.content = msg.content[0];
		msg.time = '';
	} else {
    let time = new Date();
    let h = String(time.getHours());

    let m = String(time.getMinutes());

    let s = String(time.getSeconds());
		h.length == 1 ? (h = '0' + h) : '';
		m.length == 1 ? (m = '0' + m) : '';
		s.length == 1 ? (s = '0' + s) : '';
		time = h + ':' + m + ':' + s;
		msg.time = time;
    let contentObj;
    let newContent;
		newContent = msg.content.split('}}');
		contentObj = JSON.parse(newContent[0] + '}}');
		if (contentObj.cmd == 'CustomTextMsg') {
			msg.nickName = contentObj.data.nickName;
			msg.headPic = contentObj.data.headPic;
      let content = '';
      for (let i = 1; i < newContent.length; i++) {
        if (i == newContent.length - 1) {
					content += newContent[i];
        } else {
          content += newContent[i] + '}}';
        }
			}
			msg.content = content;
		}
	}
	event.onRecvRoomTextMsg({
		roomID: roomInfo.roomID,
		userID: msg.fromAccountNick,
		nickName: msg.nickName,
		headPic: msg.headPic,
		textMsg: msg.content,
    time: msg.time,
	});
}

/**
 * [sendRoomTextMsg 发送文本消息]
 * @param {options}
 *   data: {
 *   	msg: 文本消息
 *   }
 */
function sendRoomTextMsg(options) {
	if (!options || !options.data.msg || !options.data.msg.replace(/^\s*|\s*$/g, '')) {
		console.log('sendRoomTextMsg参数错误', options);
    options.fail &&
      options.fail({
			errCode: -9,
        errMsg: 'sendRoomTextMsg参数错误',
		});
		return;
	}
  webimhandler.sendCustomMsg(
    {
		data: '{"cmd":"CustomTextMsg","data":{"nickName":"' + accountInfo.userName + '","headPic":"' + accountInfo.userAvatar + '"}}',
      text: options.data.msg,
    },
    function() {
		options.success && options.success();
    },
  );
}

/**
 * [mergePushers pushers merge操作]
 * @param {options}
 *
 * @return event.onPusherJoin
 *   pushers: 进房人员列表
 *
 * @return event.onPusherQuit
 *   pushers: 退房人员列表
 */
function mergePushers() {
	getPushers({
		data: {
      roomID: roomInfo.roomID,
		},
		success: function (ret) {
			/**
			 * enterPushers：新进推流人员信息
			 * leavePushers：退出推流人员信息
			 * ishave：用于判断去重操作
			 */
      let enterPushers = [];

      let leavePushers = [];

      let ishave = 0;
			console.log('去重操作');
			console.log('旧', roomInfo.pushers);
			console.log('新', ret.pushers);
			ret.pushers.forEach(function (val1) {
				ishave = 0;
				roomInfo.pushers.forEach(function (val2) {
					if (val1.userID == val2.userID) {
						ishave = 1;
					}
				});
        if (!ishave) {
					enterPushers.push(val1);
        }
				ishave = 0;
			});
			roomInfo.pushers.forEach(function (val1) {
				ishave = 0;
				ret.pushers.forEach(function (val2) {
					if (val1.userID == val2.userID) {
						ishave = 1;
					}
				});
        if (!ishave) {
					leavePushers.push(val1);
        }
				ishave = 0;
			});
			roomInfo.roomID = ret.roomID;
			roomInfo.roomInfo = ret.roomInfo;
      roomInfo.roomCreator = ret.roomCreator;
			// 重置roomInfo.pushers
			roomInfo.pushers = ret.pushers;
			// 通知有人进入房间
			if (enterPushers.length) {
				console.log('进房:', JSON.stringify(enterPushers));
				event.onPusherJoin({
          pushers: enterPushers,
				});
			}
			// 通知有人退出房间
			if (leavePushers.length) {
				console.log('退房:', JSON.stringify(leavePushers));
				event.onPusherQuit({
          pushers: leavePushers,
				});
			}
		},
		fail: function (ret) {
			// event.onRoomClose({
			// 	errCode: ret.errCode,
			// 	errMsg: ret.errMsg
			// });
    },
  });
		}

/**
 * [pusherHeartBeat 推流者心跳]
 * @param {options}
 */
function pusherHeartBeat(options) {
	if (options) {
		setTimeout(function () {
			proto_pusherHeartBeat();
		}, 3000);
	}
	if (heart) {
		setTimeout(function () {
			proto_pusherHeartBeat();
			pusherHeartBeat();
		}, 7000);
	}
}

function proto_pusherHeartBeat() {
	console.log('心跳请求');
	request({
		url: 'pusher_heartbeat',
		data: {
			roomID: roomInfo.roomID,
      userID: accountInfo.userID,
		},
		success: function (ret) {
			if (ret.data.code) {
				console.log('心跳失败：', ret);
				return;
			}
			console.log('心跳成功', ret);
		},
		fail: function (ret) {
			console.log('心跳失败：', ret);
    },
	});
}

/**
 * [stopPusherHeartBeat 停止推流者心跳]
 * @param {options}
 */
function stopPusherHeartBeat() {
	heart = false;
}

/**
 * [getRoomList 获取房间列表]
 * @param {options}
 *   data: {
 *   	index: 获取的房间开始索引，从0开始计算
 *   	cnt: 获取的房间个数
 *   }
 *   success: 成功回调
 *   fail: 失败回调
 *
 * @return success
 *   rooms: 房间列表信息
 */
function getRoomList(options) {
	if (!options) {
		console.log('getRoomList参数错误', options);
    options.fail &&
      options.fail({
			errCode: -9,
        errMsg: 'getRoomList参数错误',
		});
		return;
	}
	request({
		url: 'get_room_list',
		data: {
			index: options.data.index || 0,
      cnt: options.data.cnt || 20,
		},
		success: function (ret) {
			if (ret.data.code) {
				console.error('获取房间列表失败: ', ret);
        options.fail &&
          options.fail({
					errCode: ret.data.code,
            errMsg: ret.data.message + '[' + ret.data.code + ']',
				});
				return;
			}
      console.log('房间列表信息:', ret);
      options.success &&
        options.success({
          rooms: ret.data.rooms,
			});
		},
		fail: function (ret) {
      let errCode;
      let errMsg;
			console.log('获取房间列表失败: ', ret);
			if (ret.errMsg == 'request:fail timeout') {
        errCode = -1;
        errMsg = '网络请求超时，请检查网络状态';
			}
      options.fail &&
        options.fail({
				errCode: errCode || -1,
          errMsg: errMsg || '获取房间列表失败',
			});
    },
	});
}

/**
 * [getPushURL 获取推流地址]
 * @param {options}
 * 	 data: {
 * 		roomID: 房间号，可选填，后台会使用roomID和userID生成流URL，如果没有roomID，后台会使用随机数代替
 * 	 }
 *   success: 成功回调
 *   fail: 失败回调
 *
 * @return success
 *   pushURL: 推流地址
 */
function getPushURL(options) {
	if (!options) {
		console.log('getPushURL参数错误', options);
    options.fail &&
      options.fail({
			errCode: -9,
        errMsg: 'getPushURL参数错误',
		});
		return;
	}

  let data = {};
	if (options.data.roomID) {
		data.roomID = options.data.roomID;
		data.userID = accountInfo.userID;
	} else {
		data.userID = accountInfo.userID;
	}
	request({
		url: 'get_push_url',
		data: data,
		success: function (ret) {
			if (ret.data.code) {
				console.log('获取推流地址失败: ', ret);
        options.fail &&
          options.fail({
					errCode: ret.data.code,
            errMsg: ret.data.message + '[' + ret.data.code + ']',
				});
				return;
			}
			console.log('获取推流地址成功：', ret.data.pushURL);
      options.success &&
        options.success({
          pushURL: ret.data.pushURL,
			});
		},
		fail: function (ret) {
      let errCode;
      let errMsg;
			if (ret.errMsg == 'request:fail timeout') {
        errCode = -1;
        errMsg = '网络请求超时，请检查网络状态';
			}
      options.fail &&
        options.fail({
				errCode: errCode || -3,
          errMsg: errMsg || '获取推流地址失败',
        });
    },
			});
		}

/**
 * [getPushers 拉取所有主播信息]
 * @param {options}
 * 	 data.roomID: 房间号
 *   success: 成功回调
 *   fail: 失败回调
 *
 * @return success
 *   mixedPlayURL: 混流地址
 *   pushers: 房间成员
 */
function getPushers(options) {
	if (!options) {
		console.log('getPushers参数错误', options);
    options.fail &&
      options.fail({
			errCode: -9,
        errMsg: 'getPushers参数错误',
		});
		return;
	}
	request({
		url: 'get_pushers',
		data: {
      roomID: options.data.roomID,
		},
		success: function (ret) {
			if (ret.data.code) {
				console.log('拉取所有主播信息失败: ', ret);
        options.fail &&
          options.fail({
					errCode: ret.data.code,
            errMsg: ret.data.message + '[' + ret.data.code + ']',
				});
				return;
			}
			console.log('拉取所有主播信息成功', ret.data);
      let returnPushers = [];

      let isInRoom = 0;
			ret.data.pushers.forEach(function (val) {
				//剔除自己
				if (val.userID != accountInfo.userID) {
					returnPushers.push(val);
				} else {
					isInRoom = 1;
				}
			});
			if (options.type && !isInRoom) {
        options.fail &&
          options.fail({
					errCode: -1,
            errMsg: '你已退出',
				});
				return;
			}
      options.success &&
        options.success({
				roomID: ret.data.roomID,
				roomInfo: ret.data.roomInfo,
				roomCreator: ret.data.roomCreator,
				mixedPlayURL: ret.data.mixedPlayURL,
          pushers: returnPushers,
			});
		},
		fail: function (ret) {
      let errCode;
      let errMsg;
			if (ret.errMsg == 'request:fail timeout') {
        errCode = -1;
        errMsg = '网络请求超时，请检查网络状态';
			}
      options.fail &&
        options.fail({
				errCode: errCode || -1,
          errMsg: errMsg || '获取主播信息失败',
			});
    },
	});
}

/**
 * [setListener 设置监听事件]
 * @param {options}
 *   onGetPusherList: 初始化成员列表
 *   onPusherJoin: 进房通知
 *   onPusherQuit: 退房通知
 *   onRoomClose: 群解散通知
 *   onRecvRoomTextMsg: 消息通知
 */
function setListener(options) {
	if (!options) {
		console.log('setListener参数错误', options);
		return;
	}
	event.onGetPusherList = options.onGetPusherList || function () {};
	event.onPusherJoin = options.onPusherJoin || function () {};
	event.onPusherQuit = options.onPusherQuit || function () {};
	event.onRoomClose = options.onRoomClose || function () {};
	event.onRecvRoomTextMsg = options.onRecvRoomTextMsg || function () {};
}

/**
 * [createRoom 创建房间]
 * @param {options}
 *   data: {
 *   	roomInfo: 房间信息
 *   }
 *   success: 成功回调
 *   fail: 失败回调
 */
function createRoom(options) {
	roomInfo.isDestory = false;
	if (!options) {
		console.log('createRoom参数错误', options);
    options.fail &&
      options.fail({
			errCode: -9,
        errMsg: 'createRoom参数错误',
		});
		return;
	}
	roomInfo.roomInfo = options.data.roomInfo || '';
	roomInfo.pushers = [];
	proto_createRoom(options);
}

function proto_createRoom(options) {
  request({
    url: 'create_room',
    data: {
    userID: accountInfo.userID,
    roomInfo: roomInfo.roomInfo,
      roomID: options.data.roomID,
    },
		success: function (ret) {
			if (ret.data.code) {
				console.log('创建房间失败:', ret);
        options.fail &&
          options.fail({
					errCode: ret.data.code,
            errMsg: ret.data.message + '[' + ret.data.code + ']',
				});
				return;
			}
			console.log('创建房间成功');
			roomInfo.roomID = ret.data.roomID;
			roomInfo.roomCreator = accountInfo.userID;
			if (roomInfo.isDestory) {
				exitRoom({});
				return;
			}
      options.success &&
        options.success({
          roomID: roomInfo.roomID,
			});
		},
		fail: function (ret) {
      let errCode;
      let errMsg;
			console.log('创建后台房间失败:', ret);
			if (ret.errMsg == 'request:fail timeout') {
        errCode = -1;
        errMsg = '网络请求超时，请检查网络状态';
			}
      options.fail &&
        options.fail({
				errCode: errCode || -3,
          errMsg: errMsg || '创建房间失败',
			});
    },
	});
}

/**
 * [joinPusher 加入推流]
 * @param {options}
 *   data: {
 *   	roomID: 房间ID
 *   	pushURL: 推流地址
 * 		roomInfo: 房间名称
 *   }
 *   success: 成功回调
 *   fail: 失败回调
 */
function joinPusher(options) {
	if (!options || !options.data.roomID || !options.data.pushURL) {
		console.log('joinPusher参数错误', options);
    options.fail &&
      options.fail({
			errCode: -9,
        errMsg: 'joinPusher参数错误',
		});
		return;
	}
	roomInfo.roomID = options.data.roomID;
	roomInfo.roomInfo = options.data.roomInfo;
	proto_joinPusher(options);
}

function proto_joinPusher(options) {
	request({
		url: 'add_pusher',
		data: {
			roomID: roomInfo.roomID,
			roomInfo: roomInfo.roomInfo,
			userID: accountInfo.userID,
			userName: accountInfo.userName,
			userAvatar: accountInfo.userAvatar,
      pushURL: options.data.pushURL,
		},
		success: function (ret) {
			if (ret.data.code) {
				console.log('进入房间失败:', ret);
        options.fail &&
          options.fail({
					errCode: ret.data.code,
            errMsg: ret.data.message + '[' + ret.data.code + ']',
				});
				return;
			}
			console.log('加入推流成功');
			// 开始心跳
			heart = true;
			pusherHeartBeat(1);
			// 进入IM群
			webimhandler.applyJoinBigGroup(roomInfo.roomID, afterJoinBigGroup, {
				success: function () {
					options.success && options.success({});
				},
        fail: options.fail,
			});
			mergePushers();
		},
		fail: function (ret) {
      let errCode;
      let errMsg;
			console.log('进入房间失败:', ret);
			if (ret.errMsg == 'request:fail timeout') {
        errCode = -1;
        errMsg = '网络请求超时，请检查网络状态';
			}
      options.fail &&
        options.fail({
				errCode: errCode || -4,
          errMsg: errMsg || '进入房间失败',
			});
    },
	});
}

/**
 * [enterRoom 进入房间]
 * @param {options}
 *   data: {
 *   	roomID: 房间ID
 *   	pushURL: 推流地址
 * 		roomInfo: 房间名称
 *   }
 *   success: 成功回调
 *   fail: 失败回调
 */
function enterRoom(options) {
	roomInfo.isDestory = false;
	joinPusher(options);
}

/**
 * [clearRequest 中断请求]
 * @param {options}
 */
function clearRequest() {
  for (let i = 0; i < requestSeq; i++) {
		requestTask[i].abort();
	}
	requestTask = [];
	requestSeq = 0;
}

/**
 * [exitRoom 退出房间]
 * @param {options}
 */
function exitRoom(options) {
	// 停止心跳
	stopPusherHeartBeat();
	// clearRequest();
	if (roomInfo.isDestory) return;
	roomInfo.isDestory = true;
  let roomCreator = roomInfo.roomCreator;
	if (roomInfo.roomID) {
		request({
			url: 'delete_pusher',
			data: {
				roomID: roomInfo.roomID,
        userID: accountInfo.userID,
			},
			success: function (ret) {
				//非房间创建者回调
				// if (roomCreator != roomInfo.roomCreator) {
				if (ret.data.code) {
					console.error('退出房间失败:', ret);
          console.error('退房信息: roomID:' + roomInfo.roomID + ', userID:' + accountInfo.userID);
          options.fail &&
            options.fail({
						errCode: ret.data.code,
              errMsg: ret.data.message + '[' + ret.data.code + ']',
					});
					return;
				}
				console.log('退出推流成功');
				options.success && options.success({});
				// }
			},
			fail: function (ret) {
				//非房间创建者回调
				// if (roomCreator != roomInfo.roomCreator) {
				console.log('退出房间失败:', ret);
        let errCode = ret.errCode || -1;
        let errMsg = ret.errMsg || '退出房间失败';
				if (ret.errMsg == 'request:fail timeout') {
					errCode = -1;
					errMsg = '网络请求超时，请检查网络状态';
				}
        options.fail &&
          options.fail({
					errCode: errCode,
            errMsg: errMsg,
				});
				// }
      },
		});
	}

	webimhandler.quitBigGroup(); // 退出IM大群

	roomInfo.roomID = '';
	roomInfo.pushers = [];
  roomInfo.mixedPlayURL = '';
  roomInfo.roomInfo = '';
  accountInfo.pushURL = '';
	accountInfo.isCreator = false;
}

function getAccountInfo() {
	return accountInfo;
}

function getRoomInfo() {
	return roomInfo;
}
function setUserName(userName = '') {
  accountInfo.userName = userName;
  console.log('=====================昵称修改成功', accountInfo);
}
/**
 * 对外暴露函数
 * @type {Object}
 */
module.exports = {
	login: login, // 初始化
	logout: logout, // 结束初始化
	getRoomList: getRoomList, // 拉取房间列表
	getPushURL: getPushURL, // 拉取推流地址
	createRoom: createRoom, // 创建房间
	getPushers: getPushers,
	enterRoom: enterRoom, // 加入房间，如果房间号不存在，则后台会新建一个
	exitRoom: exitRoom, // 退出房间
	sendRoomTextMsg: sendRoomTextMsg, // 发送文本消息
	setListener: setListener, // 设置监听事件
	getAccountInfo: getAccountInfo,
  getRoomInfo: getRoomInfo,
  setUserName: setUserName,
};
